//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS RedshiftServerless service.
///
/// This is an interface reference for Amazon Redshift Serverless.  It contains documentation for one of the programming or command line interfaces you can use to manage Amazon Redshift Serverless.  Amazon Redshift Serverless automatically provisions data warehouse capacity and intelligently scales the  underlying resources based on workload demands. Amazon Redshift Serverless adjusts capacity in seconds to deliver consistently high  performance and simplified operations for even the most demanding and volatile workloads. Amazon Redshift Serverless lets you focus on using your data to acquire new insights for your business and customers.  To learn more about Amazon Redshift Serverless, see What is Amazon Redshift Serverless?.
public struct RedshiftServerless: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the RedshiftServerless client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "RedshiftServerless",
            serviceName: "RedshiftServerless",
            serviceIdentifier: "redshift-serverless",
            serviceProtocol: .json(version: "1.1"),
            apiVersion: "2021-04-21",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: RedshiftServerlessErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "ca-central-1": "redshift-serverless-fips.ca-central-1.amazonaws.com",
            "us-east-1": "redshift-serverless-fips.us-east-1.amazonaws.com",
            "us-east-2": "redshift-serverless-fips.us-east-2.amazonaws.com",
            "us-gov-east-1": "redshift-serverless-fips.us-gov-east-1.amazonaws.com",
            "us-gov-west-1": "redshift-serverless-fips.us-gov-west-1.amazonaws.com",
            "us-west-1": "redshift-serverless-fips.us-west-1.amazonaws.com",
            "us-west-2": "redshift-serverless-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Converts a recovery point to a snapshot. For more information about recovery points and snapshots,  see Working with snapshots and recovery points.
    @Sendable
    @inlinable
    public func convertRecoveryPointToSnapshot(_ input: ConvertRecoveryPointToSnapshotRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ConvertRecoveryPointToSnapshotResponse {
        try await self.client.execute(
            operation: "ConvertRecoveryPointToSnapshot", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Converts a recovery point to a snapshot. For more information about recovery points and snapshots,  see Working with snapshots and recovery points.
    ///
    /// Parameters:
    ///   - recoveryPointId: The unique identifier of the recovery point.
    ///   - retentionPeriod: How long to retain the snapshot.
    ///   - snapshotName: The name of the snapshot.
    ///   - tags: An array of Tag objects  to associate with the created snapshot.
    ///   - logger: Logger use during operation
    @inlinable
    public func convertRecoveryPointToSnapshot(
        recoveryPointId: String,
        retentionPeriod: Int? = nil,
        snapshotName: String,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ConvertRecoveryPointToSnapshotResponse {
        let input = ConvertRecoveryPointToSnapshotRequest(
            recoveryPointId: recoveryPointId, 
            retentionPeriod: retentionPeriod, 
            snapshotName: snapshotName, 
            tags: tags
        )
        return try await self.convertRecoveryPointToSnapshot(input, logger: logger)
    }

    /// Creates a custom domain association for Amazon Redshift Serverless.
    @Sendable
    @inlinable
    public func createCustomDomainAssociation(_ input: CreateCustomDomainAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCustomDomainAssociationResponse {
        try await self.client.execute(
            operation: "CreateCustomDomainAssociation", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a custom domain association for Amazon Redshift Serverless.
    ///
    /// Parameters:
    ///   - customDomainCertificateArn: The custom domain name’s certificate Amazon resource name (ARN).
    ///   - customDomainName: The custom domain name to associate with the workgroup.
    ///   - workgroupName: The name of the workgroup associated with the database.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCustomDomainAssociation(
        customDomainCertificateArn: String,
        customDomainName: String,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCustomDomainAssociationResponse {
        let input = CreateCustomDomainAssociationRequest(
            customDomainCertificateArn: customDomainCertificateArn, 
            customDomainName: customDomainName, 
            workgroupName: workgroupName
        )
        return try await self.createCustomDomainAssociation(input, logger: logger)
    }

    /// Creates an Amazon Redshift Serverless managed VPC endpoint.
    @Sendable
    @inlinable
    public func createEndpointAccess(_ input: CreateEndpointAccessRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateEndpointAccessResponse {
        try await self.client.execute(
            operation: "CreateEndpointAccess", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Redshift Serverless managed VPC endpoint.
    ///
    /// Parameters:
    ///   - endpointName: The name of the VPC endpoint. An endpoint name must contain 1-30 characters.  Valid characters are A-Z, a-z, 0-9, and hyphen(-). The first character must be a letter.  The name can't contain two consecutive hyphens or end with a hyphen.
    ///   - ownerAccount: The owner Amazon Web Services account for the Amazon Redshift Serverless workgroup.
    ///   - subnetIds: The unique identifers of subnets from which  Amazon Redshift Serverless chooses one to deploy a VPC endpoint.
    ///   - vpcSecurityGroupIds: The unique identifiers of the security group that defines the ports,  protocols, and sources for inbound traffic that you are authorizing into your endpoint.
    ///   - workgroupName: The name of the workgroup to associate with the VPC endpoint.
    ///   - logger: Logger use during operation
    @inlinable
    public func createEndpointAccess(
        endpointName: String,
        ownerAccount: String? = nil,
        subnetIds: [String],
        vpcSecurityGroupIds: [String]? = nil,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateEndpointAccessResponse {
        let input = CreateEndpointAccessRequest(
            endpointName: endpointName, 
            ownerAccount: ownerAccount, 
            subnetIds: subnetIds, 
            vpcSecurityGroupIds: vpcSecurityGroupIds, 
            workgroupName: workgroupName
        )
        return try await self.createEndpointAccess(input, logger: logger)
    }

    /// Creates a namespace in Amazon Redshift Serverless.
    @Sendable
    @inlinable
    public func createNamespace(_ input: CreateNamespaceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateNamespaceResponse {
        try await self.client.execute(
            operation: "CreateNamespace", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a namespace in Amazon Redshift Serverless.
    ///
    /// Parameters:
    ///   - adminPasswordSecretKmsKeyId: The ID of the Key Management Service (KMS) key used to encrypt and store the namespace's admin credentials secret.  You can only use this parameter if manageAdminPassword is true.
    ///   - adminUsername: The username of the administrator for the first database created in the namespace.
    ///   - adminUserPassword: The password of the administrator for the first database created in the namespace. You can't use adminUserPassword if manageAdminPassword is true.
    ///   - dbName: The name of the first database created in the namespace.
    ///   - defaultIamRoleArn: The Amazon Resource Name (ARN) of the IAM role to set as a default in the namespace.
    ///   - iamRoles: A list of IAM roles to associate with the namespace.
    ///   - kmsKeyId: The ID of the Amazon Web Services Key Management Service key used to encrypt your data.
    ///   - logExports: The types of logs the namespace can export.  Available export types are userlog, connectionlog, and useractivitylog.
    ///   - manageAdminPassword: If true, Amazon Redshift uses Secrets Manager to manage the namespace's admin credentials.  You can't use adminUserPassword if manageAdminPassword is true.  If manageAdminPassword is false or not set, Amazon Redshift uses  adminUserPassword for the admin user account's password.
    ///   - namespaceName: The name of the namespace.
    ///   - redshiftIdcApplicationArn: The ARN for the Redshift application that integrates with IAM Identity Center.
    ///   - tags: A list of tag instances.
    ///   - logger: Logger use during operation
    @inlinable
    public func createNamespace(
        adminPasswordSecretKmsKeyId: String? = nil,
        adminUsername: String? = nil,
        adminUserPassword: String? = nil,
        dbName: String? = nil,
        defaultIamRoleArn: String? = nil,
        iamRoles: [String]? = nil,
        kmsKeyId: String? = nil,
        logExports: [LogExport]? = nil,
        manageAdminPassword: Bool? = nil,
        namespaceName: String,
        redshiftIdcApplicationArn: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateNamespaceResponse {
        let input = CreateNamespaceRequest(
            adminPasswordSecretKmsKeyId: adminPasswordSecretKmsKeyId, 
            adminUsername: adminUsername, 
            adminUserPassword: adminUserPassword, 
            dbName: dbName, 
            defaultIamRoleArn: defaultIamRoleArn, 
            iamRoles: iamRoles, 
            kmsKeyId: kmsKeyId, 
            logExports: logExports, 
            manageAdminPassword: manageAdminPassword, 
            namespaceName: namespaceName, 
            redshiftIdcApplicationArn: redshiftIdcApplicationArn, 
            tags: tags
        )
        return try await self.createNamespace(input, logger: logger)
    }

    /// Creates an Amazon Redshift Serverless reservation, which gives you the option to commit to a specified number of Redshift Processing Units (RPUs)  for a year at a discount from Serverless on-demand (OD) rates.
    @Sendable
    @inlinable
    public func createReservation(_ input: CreateReservationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateReservationResponse {
        try await self.client.execute(
            operation: "CreateReservation", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Redshift Serverless reservation, which gives you the option to commit to a specified number of Redshift Processing Units (RPUs)  for a year at a discount from Serverless on-demand (OD) rates.
    ///
    /// Parameters:
    ///   - capacity: The number of Redshift Processing Units (RPUs) to reserve.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services  SDK populates this field. This token must be a valid UUIDv4 value. For more information about idempotency, see  Making retries safe with idempotent APIs .
    ///   - offeringId: The ID of the offering associated with the reservation. The offering determines the payment schedule for the reservation.
    ///   - logger: Logger use during operation
    @inlinable
    public func createReservation(
        capacity: Int = 0,
        clientToken: String? = CreateReservationRequest.idempotencyToken(),
        offeringId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateReservationResponse {
        let input = CreateReservationRequest(
            capacity: capacity, 
            clientToken: clientToken, 
            offeringId: offeringId
        )
        return try await self.createReservation(input, logger: logger)
    }

    /// Creates a scheduled action. A scheduled action contains a schedule and an Amazon Redshift API action.  For example, you can create a schedule of when to run the CreateSnapshot API operation.
    @Sendable
    @inlinable
    public func createScheduledAction(_ input: CreateScheduledActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateScheduledActionResponse {
        try await self.client.execute(
            operation: "CreateScheduledAction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a scheduled action. A scheduled action contains a schedule and an Amazon Redshift API action.  For example, you can create a schedule of when to run the CreateSnapshot API operation.
    ///
    /// Parameters:
    ///   - enabled: Indicates whether the schedule is enabled. If false, the scheduled action does not trigger. For more information about state  of the scheduled action, see ScheduledAction.
    ///   - endTime: The end time in UTC when the schedule is no longer active. After this time, the scheduled action does not trigger.
    ///   - namespaceName: The name of the namespace for which to create a scheduled action.
    ///   - roleArn: The ARN of the IAM role to assume to run the scheduled action. This IAM role must have permission to run the Amazon Redshift Serverless API operation in the scheduled action.  This IAM role must allow the Amazon Redshift scheduler to schedule creating snapshots. (Principal scheduler.redshift.amazonaws.com) to assume permissions on your behalf.  For more information about the IAM role to use with the Amazon Redshift scheduler, see Using Identity-Based Policies for  Amazon Redshift in the Amazon Redshift Management Guide
    ///   - schedule: The schedule for a one-time (at timestamp format) or recurring (cron format) scheduled action. Schedule invocations must be separated by at least one hour. Times are in UTC.   Format of at timestamp is yyyy-mm-ddThh:mm:ss. For example, 2016-03-04T17:27:00.   Format of cron expression is (Minutes Hours Day-of-month Month Day-of-week Year). For example, "(0 10 ? * MON *)". For more information, see  Cron Expressions in the Amazon CloudWatch Events User Guide.
    ///   - scheduledActionDescription: The description of the scheduled action.
    ///   - scheduledActionName: The name of the scheduled action.
    ///   - startTime: The start time in UTC when the schedule is active. Before this time, the scheduled action does not trigger.
    ///   - targetAction: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createScheduledAction(
        enabled: Bool? = nil,
        endTime: Date? = nil,
        namespaceName: String,
        roleArn: String,
        schedule: Schedule,
        scheduledActionDescription: String? = nil,
        scheduledActionName: String,
        startTime: Date? = nil,
        targetAction: TargetAction,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateScheduledActionResponse {
        let input = CreateScheduledActionRequest(
            enabled: enabled, 
            endTime: endTime, 
            namespaceName: namespaceName, 
            roleArn: roleArn, 
            schedule: schedule, 
            scheduledActionDescription: scheduledActionDescription, 
            scheduledActionName: scheduledActionName, 
            startTime: startTime, 
            targetAction: targetAction
        )
        return try await self.createScheduledAction(input, logger: logger)
    }

    /// Creates a snapshot of all databases in a namespace. For more information about snapshots, see   Working with snapshots and recovery points.
    @Sendable
    @inlinable
    public func createSnapshot(_ input: CreateSnapshotRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSnapshotResponse {
        try await self.client.execute(
            operation: "CreateSnapshot", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a snapshot of all databases in a namespace. For more information about snapshots, see   Working with snapshots and recovery points.
    ///
    /// Parameters:
    ///   - namespaceName: The namespace to create a snapshot for.
    ///   - retentionPeriod: How long to retain the created snapshot.
    ///   - snapshotName: The name of the snapshot.
    ///   - tags: An array of Tag objects to associate with the snapshot.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSnapshot(
        namespaceName: String,
        retentionPeriod: Int? = nil,
        snapshotName: String,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSnapshotResponse {
        let input = CreateSnapshotRequest(
            namespaceName: namespaceName, 
            retentionPeriod: retentionPeriod, 
            snapshotName: snapshotName, 
            tags: tags
        )
        return try await self.createSnapshot(input, logger: logger)
    }

    /// Creates a snapshot copy configuration that lets you copy snapshots to another Amazon Web Services Region.
    @Sendable
    @inlinable
    public func createSnapshotCopyConfiguration(_ input: CreateSnapshotCopyConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSnapshotCopyConfigurationResponse {
        try await self.client.execute(
            operation: "CreateSnapshotCopyConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a snapshot copy configuration that lets you copy snapshots to another Amazon Web Services Region.
    ///
    /// Parameters:
    ///   - destinationKmsKeyId: The KMS key to use to encrypt your snapshots in the destination Amazon Web Services Region.
    ///   - destinationRegion: The destination Amazon Web Services Region that you want to copy snapshots to.
    ///   - namespaceName: The name of the namespace to copy snapshots from.
    ///   - snapshotRetentionPeriod: The retention period of the snapshots that you copy to the destination Amazon Web Services Region.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSnapshotCopyConfiguration(
        destinationKmsKeyId: String? = nil,
        destinationRegion: String,
        namespaceName: String,
        snapshotRetentionPeriod: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSnapshotCopyConfigurationResponse {
        let input = CreateSnapshotCopyConfigurationRequest(
            destinationKmsKeyId: destinationKmsKeyId, 
            destinationRegion: destinationRegion, 
            namespaceName: namespaceName, 
            snapshotRetentionPeriod: snapshotRetentionPeriod
        )
        return try await self.createSnapshotCopyConfiguration(input, logger: logger)
    }

    /// Creates a usage limit for a specified Amazon Redshift Serverless usage type. The usage limit is identified by the returned usage limit identifier.
    @Sendable
    @inlinable
    public func createUsageLimit(_ input: CreateUsageLimitRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateUsageLimitResponse {
        try await self.client.execute(
            operation: "CreateUsageLimit", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a usage limit for a specified Amazon Redshift Serverless usage type. The usage limit is identified by the returned usage limit identifier.
    ///
    /// Parameters:
    ///   - amount: The limit amount. If time-based, this amount is in Redshift Processing Units (RPU) consumed per hour. If data-based, this amount is in terabytes (TB) of data transferred between Regions in cross-account sharing. The value must be a positive number.
    ///   - breachAction: The action that Amazon Redshift Serverless takes when the limit is reached. The default is log.
    ///   - period: The time period that the amount applies to. A weekly period begins on Sunday. The default is monthly.
    ///   - resourceArn: The Amazon Resource Name (ARN) of the Amazon Redshift Serverless resource to create the usage limit for.
    ///   - usageType: The type of Amazon Redshift Serverless usage to create a usage limit for.
    ///   - logger: Logger use during operation
    @inlinable
    public func createUsageLimit(
        amount: Int64,
        breachAction: UsageLimitBreachAction? = nil,
        period: UsageLimitPeriod? = nil,
        resourceArn: String,
        usageType: UsageLimitUsageType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateUsageLimitResponse {
        let input = CreateUsageLimitRequest(
            amount: amount, 
            breachAction: breachAction, 
            period: period, 
            resourceArn: resourceArn, 
            usageType: usageType
        )
        return try await self.createUsageLimit(input, logger: logger)
    }

    /// Creates an workgroup in Amazon Redshift Serverless. VPC Block Public Access (BPA) enables you to block resources in VPCs and subnets that you own in a Region from reaching or being reached from the internet through internet gateways and egress-only internet gateways. If a workgroup is in an account with VPC BPA turned on, the following capabilities are blocked:    Creating a public access workgroup   Modifying a private workgroup to public   Adding a subnet with VPC BPA turned on to the workgroup when the workgroup is public   For more information about VPC BPA, see Block public access to VPCs and subnets in the Amazon VPC User Guide.
    @Sendable
    @inlinable
    public func createWorkgroup(_ input: CreateWorkgroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateWorkgroupResponse {
        try await self.client.execute(
            operation: "CreateWorkgroup", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an workgroup in Amazon Redshift Serverless. VPC Block Public Access (BPA) enables you to block resources in VPCs and subnets that you own in a Region from reaching or being reached from the internet through internet gateways and egress-only internet gateways. If a workgroup is in an account with VPC BPA turned on, the following capabilities are blocked:    Creating a public access workgroup   Modifying a private workgroup to public   Adding a subnet with VPC BPA turned on to the workgroup when the workgroup is public   For more information about VPC BPA, see Block public access to VPCs and subnets in the Amazon VPC User Guide.
    ///
    /// Parameters:
    ///   - baseCapacity: The base data warehouse capacity of the workgroup in Redshift Processing Units (RPUs).
    ///   - configParameters: An array of parameters to set for advanced control over a database. The options are auto_mv, datestyle, enable_case_sensitive_identifier, enable_user_activity_logging, query_group, search_path, require_ssl, use_fips_ssl, and query monitoring metrics that let you define performance boundaries. For more information about query monitoring rules and available metrics, see   Query monitoring metrics for Amazon Redshift Serverless.
    ///   - enhancedVpcRouting: The value that specifies whether to turn on enhanced virtual  private cloud (VPC) routing, which forces Amazon Redshift Serverless to route traffic through your VPC instead of over the internet.
    ///   - ipAddressType: The IP address type that the workgroup supports. Possible values are ipv4 and dualstack.
    ///   - maxCapacity: The maximum data-warehouse capacity Amazon Redshift Serverless uses to serve queries. The max capacity is specified in RPUs.
    ///   - namespaceName: The name of the namespace to associate with the workgroup.
    ///   - port: The custom port to use when connecting to a workgroup. Valid port ranges are 5431-5455 and 8191-8215. The default is 5439.
    ///   - pricePerformanceTarget: An object that represents the price performance target settings for the workgroup.
    ///   - publiclyAccessible: A value that specifies whether the workgroup can be accessed from a public network.
    ///   - securityGroupIds: An array of security group IDs to associate with the workgroup.
    ///   - subnetIds: An array of VPC subnet IDs to associate with the workgroup.
    ///   - tags: A array of tag instances.
    ///   - trackName: An optional parameter for the name of the track for the workgroup. If you don't provide  a track name, the workgroup is assigned to the current track.
    ///   - workgroupName: The name of the created workgroup.
    ///   - logger: Logger use during operation
    @inlinable
    public func createWorkgroup(
        baseCapacity: Int? = nil,
        configParameters: [ConfigParameter]? = nil,
        enhancedVpcRouting: Bool? = nil,
        ipAddressType: String? = nil,
        maxCapacity: Int? = nil,
        namespaceName: String,
        port: Int? = nil,
        pricePerformanceTarget: PerformanceTarget? = nil,
        publiclyAccessible: Bool? = nil,
        securityGroupIds: [String]? = nil,
        subnetIds: [String]? = nil,
        tags: [Tag]? = nil,
        trackName: String? = nil,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateWorkgroupResponse {
        let input = CreateWorkgroupRequest(
            baseCapacity: baseCapacity, 
            configParameters: configParameters, 
            enhancedVpcRouting: enhancedVpcRouting, 
            ipAddressType: ipAddressType, 
            maxCapacity: maxCapacity, 
            namespaceName: namespaceName, 
            port: port, 
            pricePerformanceTarget: pricePerformanceTarget, 
            publiclyAccessible: publiclyAccessible, 
            securityGroupIds: securityGroupIds, 
            subnetIds: subnetIds, 
            tags: tags, 
            trackName: trackName, 
            workgroupName: workgroupName
        )
        return try await self.createWorkgroup(input, logger: logger)
    }

    /// Deletes a custom domain association for Amazon Redshift Serverless.
    @Sendable
    @inlinable
    public func deleteCustomDomainAssociation(_ input: DeleteCustomDomainAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCustomDomainAssociationResponse {
        try await self.client.execute(
            operation: "DeleteCustomDomainAssociation", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a custom domain association for Amazon Redshift Serverless.
    ///
    /// Parameters:
    ///   - customDomainName: The custom domain name associated with the workgroup.
    ///   - workgroupName: The name of the workgroup associated with the database.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCustomDomainAssociation(
        customDomainName: String,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCustomDomainAssociationResponse {
        let input = DeleteCustomDomainAssociationRequest(
            customDomainName: customDomainName, 
            workgroupName: workgroupName
        )
        return try await self.deleteCustomDomainAssociation(input, logger: logger)
    }

    /// Deletes an Amazon Redshift Serverless managed VPC endpoint.
    @Sendable
    @inlinable
    public func deleteEndpointAccess(_ input: DeleteEndpointAccessRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteEndpointAccessResponse {
        try await self.client.execute(
            operation: "DeleteEndpointAccess", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Redshift Serverless managed VPC endpoint.
    ///
    /// Parameters:
    ///   - endpointName: The name of the VPC endpoint to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEndpointAccess(
        endpointName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteEndpointAccessResponse {
        let input = DeleteEndpointAccessRequest(
            endpointName: endpointName
        )
        return try await self.deleteEndpointAccess(input, logger: logger)
    }

    /// Deletes a namespace from Amazon Redshift Serverless.  Before you delete the namespace, you can create a final snapshot that has all of the data within the namespace.
    @Sendable
    @inlinable
    public func deleteNamespace(_ input: DeleteNamespaceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteNamespaceResponse {
        try await self.client.execute(
            operation: "DeleteNamespace", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a namespace from Amazon Redshift Serverless.  Before you delete the namespace, you can create a final snapshot that has all of the data within the namespace.
    ///
    /// Parameters:
    ///   - finalSnapshotName: The name of the snapshot to be created before the namespace is deleted.
    ///   - finalSnapshotRetentionPeriod: How long to retain the final snapshot.
    ///   - namespaceName: The name of the namespace to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteNamespace(
        finalSnapshotName: String? = nil,
        finalSnapshotRetentionPeriod: Int? = nil,
        namespaceName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteNamespaceResponse {
        let input = DeleteNamespaceRequest(
            finalSnapshotName: finalSnapshotName, 
            finalSnapshotRetentionPeriod: finalSnapshotRetentionPeriod, 
            namespaceName: namespaceName
        )
        return try await self.deleteNamespace(input, logger: logger)
    }

    /// Deletes the specified resource policy.
    @Sendable
    @inlinable
    public func deleteResourcePolicy(_ input: DeleteResourcePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteResourcePolicyResponse {
        try await self.client.execute(
            operation: "DeleteResourcePolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified resource policy.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the policy to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteResourcePolicy(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteResourcePolicyResponse {
        let input = DeleteResourcePolicyRequest(
            resourceArn: resourceArn
        )
        return try await self.deleteResourcePolicy(input, logger: logger)
    }

    /// Deletes a scheduled action.
    @Sendable
    @inlinable
    public func deleteScheduledAction(_ input: DeleteScheduledActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteScheduledActionResponse {
        try await self.client.execute(
            operation: "DeleteScheduledAction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a scheduled action.
    ///
    /// Parameters:
    ///   - scheduledActionName: The name of the scheduled action to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteScheduledAction(
        scheduledActionName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteScheduledActionResponse {
        let input = DeleteScheduledActionRequest(
            scheduledActionName: scheduledActionName
        )
        return try await self.deleteScheduledAction(input, logger: logger)
    }

    /// Deletes a snapshot from Amazon Redshift Serverless.
    @Sendable
    @inlinable
    public func deleteSnapshot(_ input: DeleteSnapshotRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSnapshotResponse {
        try await self.client.execute(
            operation: "DeleteSnapshot", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a snapshot from Amazon Redshift Serverless.
    ///
    /// Parameters:
    ///   - snapshotName: The name of the snapshot to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSnapshot(
        snapshotName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSnapshotResponse {
        let input = DeleteSnapshotRequest(
            snapshotName: snapshotName
        )
        return try await self.deleteSnapshot(input, logger: logger)
    }

    /// Deletes a snapshot copy configuration
    @Sendable
    @inlinable
    public func deleteSnapshotCopyConfiguration(_ input: DeleteSnapshotCopyConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSnapshotCopyConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteSnapshotCopyConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a snapshot copy configuration
    ///
    /// Parameters:
    ///   - snapshotCopyConfigurationId: The ID of the snapshot copy configuration to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSnapshotCopyConfiguration(
        snapshotCopyConfigurationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSnapshotCopyConfigurationResponse {
        let input = DeleteSnapshotCopyConfigurationRequest(
            snapshotCopyConfigurationId: snapshotCopyConfigurationId
        )
        return try await self.deleteSnapshotCopyConfiguration(input, logger: logger)
    }

    /// Deletes a usage limit from Amazon Redshift Serverless.
    @Sendable
    @inlinable
    public func deleteUsageLimit(_ input: DeleteUsageLimitRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteUsageLimitResponse {
        try await self.client.execute(
            operation: "DeleteUsageLimit", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a usage limit from Amazon Redshift Serverless.
    ///
    /// Parameters:
    ///   - usageLimitId: The unique identifier of the usage limit to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteUsageLimit(
        usageLimitId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteUsageLimitResponse {
        let input = DeleteUsageLimitRequest(
            usageLimitId: usageLimitId
        )
        return try await self.deleteUsageLimit(input, logger: logger)
    }

    /// Deletes a workgroup.
    @Sendable
    @inlinable
    public func deleteWorkgroup(_ input: DeleteWorkgroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteWorkgroupResponse {
        try await self.client.execute(
            operation: "DeleteWorkgroup", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a workgroup.
    ///
    /// Parameters:
    ///   - workgroupName: The name of the workgroup to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteWorkgroup(
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteWorkgroupResponse {
        let input = DeleteWorkgroupRequest(
            workgroupName: workgroupName
        )
        return try await self.deleteWorkgroup(input, logger: logger)
    }

    /// Returns a database user name and temporary password with temporary authorization to log in to Amazon Redshift Serverless. By default, the temporary credentials expire in 900 seconds.  You can optionally specify a duration between 900 seconds (15 minutes) and 3600 seconds (60 minutes). The Identity and Access Management (IAM) user or role that runs  GetCredentials must have an IAM policy attached that allows access to all  necessary actions and resources. If the DbName parameter is specified, the IAM policy must  allow access to the resource dbname for the specified database name.
    @Sendable
    @inlinable
    public func getCredentials(_ input: GetCredentialsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCredentialsResponse {
        try await self.client.execute(
            operation: "GetCredentials", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a database user name and temporary password with temporary authorization to log in to Amazon Redshift Serverless. By default, the temporary credentials expire in 900 seconds.  You can optionally specify a duration between 900 seconds (15 minutes) and 3600 seconds (60 minutes). The Identity and Access Management (IAM) user or role that runs  GetCredentials must have an IAM policy attached that allows access to all  necessary actions and resources. If the DbName parameter is specified, the IAM policy must  allow access to the resource dbname for the specified database name.
    ///
    /// Parameters:
    ///   - customDomainName: The custom domain name associated with the workgroup. The custom domain name or the workgroup name must be included in the request.
    ///   - dbName: The name of the database to get temporary authorization to log on to. Constraints:   Must be 1 to 64 alphanumeric characters or hyphens.   Must contain only uppercase or lowercase letters, numbers, underscore, plus sign, period (dot), at symbol (@), or hyphen.   The first character must be a letter.   Must not contain a colon ( : ) or slash ( / ).   Cannot be a reserved word. A list of reserved words can be found  in Reserved Words   in the Amazon Redshift Database Developer Guide
    ///   - durationSeconds: The number of seconds until the returned temporary password expires. The minimum is 900 seconds, and the maximum is 3600 seconds.
    ///   - workgroupName: The name of the workgroup associated with the database.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCredentials(
        customDomainName: String? = nil,
        dbName: String? = nil,
        durationSeconds: Int? = nil,
        workgroupName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCredentialsResponse {
        let input = GetCredentialsRequest(
            customDomainName: customDomainName, 
            dbName: dbName, 
            durationSeconds: durationSeconds, 
            workgroupName: workgroupName
        )
        return try await self.getCredentials(input, logger: logger)
    }

    /// Gets information about a specific custom domain association.
    @Sendable
    @inlinable
    public func getCustomDomainAssociation(_ input: GetCustomDomainAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCustomDomainAssociationResponse {
        try await self.client.execute(
            operation: "GetCustomDomainAssociation", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a specific custom domain association.
    ///
    /// Parameters:
    ///   - customDomainName: The custom domain name associated with the workgroup.
    ///   - workgroupName: The name of the workgroup associated with the database.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCustomDomainAssociation(
        customDomainName: String,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCustomDomainAssociationResponse {
        let input = GetCustomDomainAssociationRequest(
            customDomainName: customDomainName, 
            workgroupName: workgroupName
        )
        return try await self.getCustomDomainAssociation(input, logger: logger)
    }

    /// Returns information, such as the name, about a VPC endpoint.
    @Sendable
    @inlinable
    public func getEndpointAccess(_ input: GetEndpointAccessRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEndpointAccessResponse {
        try await self.client.execute(
            operation: "GetEndpointAccess", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information, such as the name, about a VPC endpoint.
    ///
    /// Parameters:
    ///   - endpointName: The name of the VPC endpoint to return information for.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEndpointAccess(
        endpointName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEndpointAccessResponse {
        let input = GetEndpointAccessRequest(
            endpointName: endpointName
        )
        return try await self.getEndpointAccess(input, logger: logger)
    }

    /// Returns information about a namespace in Amazon Redshift Serverless.
    @Sendable
    @inlinable
    public func getNamespace(_ input: GetNamespaceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNamespaceResponse {
        try await self.client.execute(
            operation: "GetNamespace", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a namespace in Amazon Redshift Serverless.
    ///
    /// Parameters:
    ///   - namespaceName: The name of the namespace to retrieve information for.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNamespace(
        namespaceName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNamespaceResponse {
        let input = GetNamespaceRequest(
            namespaceName: namespaceName
        )
        return try await self.getNamespace(input, logger: logger)
    }

    /// Returns information about a recovery point.
    @Sendable
    @inlinable
    public func getRecoveryPoint(_ input: GetRecoveryPointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRecoveryPointResponse {
        try await self.client.execute(
            operation: "GetRecoveryPoint", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a recovery point.
    ///
    /// Parameters:
    ///   - recoveryPointId: The unique identifier of the recovery point to return information for.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRecoveryPoint(
        recoveryPointId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRecoveryPointResponse {
        let input = GetRecoveryPointRequest(
            recoveryPointId: recoveryPointId
        )
        return try await self.getRecoveryPoint(input, logger: logger)
    }

    /// Gets an Amazon Redshift Serverless reservation. A reservation gives you the option to commit to a specified number of Redshift Processing Units (RPUs)  for a year at a discount from Serverless on-demand (OD) rates.
    @Sendable
    @inlinable
    public func getReservation(_ input: GetReservationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReservationResponse {
        try await self.client.execute(
            operation: "GetReservation", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an Amazon Redshift Serverless reservation. A reservation gives you the option to commit to a specified number of Redshift Processing Units (RPUs)  for a year at a discount from Serverless on-demand (OD) rates.
    ///
    /// Parameters:
    ///   - reservationId: The ID of the reservation to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getReservation(
        reservationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReservationResponse {
        let input = GetReservationRequest(
            reservationId: reservationId
        )
        return try await self.getReservation(input, logger: logger)
    }

    /// Returns the reservation offering. The offering determines the payment schedule for the reservation.
    @Sendable
    @inlinable
    public func getReservationOffering(_ input: GetReservationOfferingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetReservationOfferingResponse {
        try await self.client.execute(
            operation: "GetReservationOffering", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the reservation offering. The offering determines the payment schedule for the reservation.
    ///
    /// Parameters:
    ///   - offeringId: The identifier for the offering..
    ///   - logger: Logger use during operation
    @inlinable
    public func getReservationOffering(
        offeringId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetReservationOfferingResponse {
        let input = GetReservationOfferingRequest(
            offeringId: offeringId
        )
        return try await self.getReservationOffering(input, logger: logger)
    }

    /// Returns a resource policy.
    @Sendable
    @inlinable
    public func getResourcePolicy(_ input: GetResourcePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourcePolicyResponse {
        try await self.client.execute(
            operation: "GetResourcePolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a resource policy.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource to return.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourcePolicy(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourcePolicyResponse {
        let input = GetResourcePolicyRequest(
            resourceArn: resourceArn
        )
        return try await self.getResourcePolicy(input, logger: logger)
    }

    /// Returns information about a scheduled action.
    @Sendable
    @inlinable
    public func getScheduledAction(_ input: GetScheduledActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetScheduledActionResponse {
        try await self.client.execute(
            operation: "GetScheduledAction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a scheduled action.
    ///
    /// Parameters:
    ///   - scheduledActionName: The name of the scheduled action.
    ///   - logger: Logger use during operation
    @inlinable
    public func getScheduledAction(
        scheduledActionName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetScheduledActionResponse {
        let input = GetScheduledActionRequest(
            scheduledActionName: scheduledActionName
        )
        return try await self.getScheduledAction(input, logger: logger)
    }

    /// Returns information about a specific snapshot.
    @Sendable
    @inlinable
    public func getSnapshot(_ input: GetSnapshotRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSnapshotResponse {
        try await self.client.execute(
            operation: "GetSnapshot", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a specific snapshot.
    ///
    /// Parameters:
    ///   - ownerAccount: The owner Amazon Web Services account of a snapshot shared with another user.
    ///   - snapshotArn: The Amazon Resource Name (ARN) of the snapshot to return.
    ///   - snapshotName: The name of the snapshot to return.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSnapshot(
        ownerAccount: String? = nil,
        snapshotArn: String? = nil,
        snapshotName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSnapshotResponse {
        let input = GetSnapshotRequest(
            ownerAccount: ownerAccount, 
            snapshotArn: snapshotArn, 
            snapshotName: snapshotName
        )
        return try await self.getSnapshot(input, logger: logger)
    }

    /// Returns information about a TableRestoreStatus object.
    @Sendable
    @inlinable
    public func getTableRestoreStatus(_ input: GetTableRestoreStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTableRestoreStatusResponse {
        try await self.client.execute(
            operation: "GetTableRestoreStatus", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a TableRestoreStatus object.
    ///
    /// Parameters:
    ///   - tableRestoreRequestId: The ID of the RestoreTableFromSnapshot request to return status for.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTableRestoreStatus(
        tableRestoreRequestId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTableRestoreStatusResponse {
        let input = GetTableRestoreStatusRequest(
            tableRestoreRequestId: tableRestoreRequestId
        )
        return try await self.getTableRestoreStatus(input, logger: logger)
    }

    /// Get the Redshift Serverless version for a specified track.
    @Sendable
    @inlinable
    public func getTrack(_ input: GetTrackRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTrackResponse {
        try await self.client.execute(
            operation: "GetTrack", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the Redshift Serverless version for a specified track.
    ///
    /// Parameters:
    ///   - trackName: The name of the track of which its version is fetched.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTrack(
        trackName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTrackResponse {
        let input = GetTrackRequest(
            trackName: trackName
        )
        return try await self.getTrack(input, logger: logger)
    }

    /// Returns information about a usage limit.
    @Sendable
    @inlinable
    public func getUsageLimit(_ input: GetUsageLimitRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUsageLimitResponse {
        try await self.client.execute(
            operation: "GetUsageLimit", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a usage limit.
    ///
    /// Parameters:
    ///   - usageLimitId: The unique identifier of the usage limit to return information for.
    ///   - logger: Logger use during operation
    @inlinable
    public func getUsageLimit(
        usageLimitId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUsageLimitResponse {
        let input = GetUsageLimitRequest(
            usageLimitId: usageLimitId
        )
        return try await self.getUsageLimit(input, logger: logger)
    }

    /// Returns information about a specific workgroup.
    @Sendable
    @inlinable
    public func getWorkgroup(_ input: GetWorkgroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetWorkgroupResponse {
        try await self.client.execute(
            operation: "GetWorkgroup", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a specific workgroup.
    ///
    /// Parameters:
    ///   - workgroupName: The name of the workgroup to return information for.
    ///   - logger: Logger use during operation
    @inlinable
    public func getWorkgroup(
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetWorkgroupResponse {
        let input = GetWorkgroupRequest(
            workgroupName: workgroupName
        )
        return try await self.getWorkgroup(input, logger: logger)
    }

    ///  Lists custom domain associations for Amazon Redshift Serverless.
    @Sendable
    @inlinable
    public func listCustomDomainAssociations(_ input: ListCustomDomainAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCustomDomainAssociationsResponse {
        try await self.client.execute(
            operation: "ListCustomDomainAssociations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Lists custom domain associations for Amazon Redshift Serverless.
    ///
    /// Parameters:
    ///   - customDomainCertificateArn: The custom domain name’s certificate Amazon resource name (ARN).
    ///   - customDomainName: The custom domain name associated with the workgroup.
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - nextToken: When nextToken is returned, there are more results available.  The value of nextToken is a unique pagination token for each page.  Make the call again using the returned token to retrieve the next page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCustomDomainAssociations(
        customDomainCertificateArn: String? = nil,
        customDomainName: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCustomDomainAssociationsResponse {
        let input = ListCustomDomainAssociationsRequest(
            customDomainCertificateArn: customDomainCertificateArn, 
            customDomainName: customDomainName, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCustomDomainAssociations(input, logger: logger)
    }

    /// Returns an array of EndpointAccess objects and relevant information.
    @Sendable
    @inlinable
    public func listEndpointAccess(_ input: ListEndpointAccessRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListEndpointAccessResponse {
        try await self.client.execute(
            operation: "ListEndpointAccess", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns an array of EndpointAccess objects and relevant information.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - nextToken: If your initial ListEndpointAccess operation returns a nextToken, you can include the returned nextToken in following ListEndpointAccess operations, which returns results in the next page.
    ///   - ownerAccount: The owner Amazon Web Services account for the Amazon Redshift Serverless workgroup.
    ///   - vpcId: The unique identifier of the virtual private cloud with access to Amazon Redshift Serverless.
    ///   - workgroupName: The name of the workgroup associated with the VPC endpoint to return.
    ///   - logger: Logger use during operation
    @inlinable
    public func listEndpointAccess(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        ownerAccount: String? = nil,
        vpcId: String? = nil,
        workgroupName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListEndpointAccessResponse {
        let input = ListEndpointAccessRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            ownerAccount: ownerAccount, 
            vpcId: vpcId, 
            workgroupName: workgroupName
        )
        return try await self.listEndpointAccess(input, logger: logger)
    }

    /// Returns information about a list of specified managed workgroups in your account.
    @Sendable
    @inlinable
    public func listManagedWorkgroups(_ input: ListManagedWorkgroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListManagedWorkgroupsResponse {
        try await self.client.execute(
            operation: "ListManagedWorkgroups", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a list of specified managed workgroups in your account.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number  of results to return. You can use nextToken to display the next page of results.
    ///   - nextToken: If your initial ListManagedWorkgroups operation returns a nextToken,  you can include the returned nextToken in following ListManagedWorkgroups  operations, which returns results in the next page.
    ///   - sourceArn: The Amazon Resource Name (ARN) for the managed  workgroup in the AWS Glue Data Catalog.
    ///   - logger: Logger use during operation
    @inlinable
    public func listManagedWorkgroups(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sourceArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListManagedWorkgroupsResponse {
        let input = ListManagedWorkgroupsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            sourceArn: sourceArn
        )
        return try await self.listManagedWorkgroups(input, logger: logger)
    }

    /// Returns information about a list of specified namespaces.
    @Sendable
    @inlinable
    public func listNamespaces(_ input: ListNamespacesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNamespacesResponse {
        try await self.client.execute(
            operation: "ListNamespaces", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a list of specified namespaces.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - nextToken: If your initial ListNamespaces operation returns a nextToken, you can include the returned nextToken in following ListNamespaces operations, which returns results in the next page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNamespaces(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNamespacesResponse {
        let input = ListNamespacesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listNamespaces(input, logger: logger)
    }

    /// Returns an array of recovery points.
    @Sendable
    @inlinable
    public func listRecoveryPoints(_ input: ListRecoveryPointsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRecoveryPointsResponse {
        try await self.client.execute(
            operation: "ListRecoveryPoints", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns an array of recovery points.
    ///
    /// Parameters:
    ///   - endTime: The time when creation of the recovery point finished.
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - namespaceArn: The Amazon Resource Name (ARN) of the namespace from which to list recovery points.
    ///   - namespaceName: The name of the namespace to list recovery points for.
    ///   - nextToken: If your initial ListRecoveryPoints operation returns a nextToken, you can include the returned nextToken in following ListRecoveryPoints operations, which returns results in the next page.
    ///   - startTime: The time when the recovery point's creation was initiated.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRecoveryPoints(
        endTime: Date? = nil,
        maxResults: Int? = nil,
        namespaceArn: String? = nil,
        namespaceName: String? = nil,
        nextToken: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRecoveryPointsResponse {
        let input = ListRecoveryPointsRequest(
            endTime: endTime, 
            maxResults: maxResults, 
            namespaceArn: namespaceArn, 
            namespaceName: namespaceName, 
            nextToken: nextToken, 
            startTime: startTime
        )
        return try await self.listRecoveryPoints(input, logger: logger)
    }

    /// Returns the current reservation offerings in your account.
    @Sendable
    @inlinable
    public func listReservationOfferings(_ input: ListReservationOfferingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReservationOfferingsResponse {
        try await self.client.execute(
            operation: "ListReservationOfferings", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the current reservation offerings in your account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of items to return for this call. The call also returns a token that you can specify in a subsequent call to get the next set of results.
    ///   - nextToken: The token for the next set of items to return. (You received this token from a previous call.)
    ///   - logger: Logger use during operation
    @inlinable
    public func listReservationOfferings(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReservationOfferingsResponse {
        let input = ListReservationOfferingsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listReservationOfferings(input, logger: logger)
    }

    /// Returns a list of Reservation objects.
    @Sendable
    @inlinable
    public func listReservations(_ input: ListReservationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReservationsResponse {
        try await self.client.execute(
            operation: "ListReservations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of Reservation objects.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of items to return for this call. The call also returns a token that you can specify in a subsequent call to get the next set of results.
    ///   - nextToken: The token for the next set of items to return. (You received this token from a previous call.)
    ///   - logger: Logger use during operation
    @inlinable
    public func listReservations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReservationsResponse {
        let input = ListReservationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listReservations(input, logger: logger)
    }

    /// Returns a list of scheduled actions. You can use the flags to filter the list of returned scheduled actions.
    @Sendable
    @inlinable
    public func listScheduledActions(_ input: ListScheduledActionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListScheduledActionsResponse {
        try await self.client.execute(
            operation: "ListScheduledActions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of scheduled actions. You can use the flags to filter the list of returned scheduled actions.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. Use nextToken to display the next page of results.
    ///   - namespaceName: The name of namespace associated with the scheduled action to retrieve.
    ///   - nextToken: If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page.  Make the call again using the returned token to retrieve the next page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listScheduledActions(
        maxResults: Int? = nil,
        namespaceName: String? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListScheduledActionsResponse {
        let input = ListScheduledActionsRequest(
            maxResults: maxResults, 
            namespaceName: namespaceName, 
            nextToken: nextToken
        )
        return try await self.listScheduledActions(input, logger: logger)
    }

    /// Returns a list of snapshot copy configurations.
    @Sendable
    @inlinable
    public func listSnapshotCopyConfigurations(_ input: ListSnapshotCopyConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSnapshotCopyConfigurationsResponse {
        try await self.client.execute(
            operation: "ListSnapshotCopyConfigurations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of snapshot copy configurations.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - namespaceName: The namespace from which to list all snapshot copy configurations.
    ///   - nextToken: If nextToken is returned, there are more results available. The value of nextToken is a unique pagination token for each page. Make the call again using  the returned token to retrieve the next page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSnapshotCopyConfigurations(
        maxResults: Int? = nil,
        namespaceName: String? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSnapshotCopyConfigurationsResponse {
        let input = ListSnapshotCopyConfigurationsRequest(
            maxResults: maxResults, 
            namespaceName: namespaceName, 
            nextToken: nextToken
        )
        return try await self.listSnapshotCopyConfigurations(input, logger: logger)
    }

    /// Returns a list of snapshots.
    @Sendable
    @inlinable
    public func listSnapshots(_ input: ListSnapshotsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSnapshotsResponse {
        try await self.client.execute(
            operation: "ListSnapshots", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of snapshots.
    ///
    /// Parameters:
    ///   - endTime: The timestamp showing when the snapshot creation finished.
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - namespaceArn: The Amazon Resource Name (ARN) of the namespace from which to list all snapshots.
    ///   - namespaceName: The namespace from which to list all snapshots.
    ///   - nextToken: If nextToken is returned, there are more results available.  The value of nextToken is a unique pagination token for each page.  Make the call again using the returned token to retrieve the next page.
    ///   - ownerAccount: The owner Amazon Web Services account of the snapshot.
    ///   - startTime: The time when the creation of the snapshot was initiated.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSnapshots(
        endTime: Date? = nil,
        maxResults: Int? = nil,
        namespaceArn: String? = nil,
        namespaceName: String? = nil,
        nextToken: String? = nil,
        ownerAccount: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSnapshotsResponse {
        let input = ListSnapshotsRequest(
            endTime: endTime, 
            maxResults: maxResults, 
            namespaceArn: namespaceArn, 
            namespaceName: namespaceName, 
            nextToken: nextToken, 
            ownerAccount: ownerAccount, 
            startTime: startTime
        )
        return try await self.listSnapshots(input, logger: logger)
    }

    /// Returns information about an array of TableRestoreStatus objects.
    @Sendable
    @inlinable
    public func listTableRestoreStatus(_ input: ListTableRestoreStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTableRestoreStatusResponse {
        try await self.client.execute(
            operation: "ListTableRestoreStatus", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about an array of TableRestoreStatus objects.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to  return. You can use nextToken to display the next page of results.
    ///   - namespaceName: The namespace from which to list all of the statuses of RestoreTableFromSnapshot operations .
    ///   - nextToken: If your initial ListTableRestoreStatus operation returns a nextToken,  you can include the returned nextToken in following ListTableRestoreStatus operations. This will return results on the next page.
    ///   - workgroupName: The workgroup from which to list all of the statuses of RestoreTableFromSnapshot operations.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTableRestoreStatus(
        maxResults: Int? = nil,
        namespaceName: String? = nil,
        nextToken: String? = nil,
        workgroupName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTableRestoreStatusResponse {
        let input = ListTableRestoreStatusRequest(
            maxResults: maxResults, 
            namespaceName: namespaceName, 
            nextToken: nextToken, 
            workgroupName: workgroupName
        )
        return try await self.listTableRestoreStatus(input, logger: logger)
    }

    /// Lists the tags assigned to a resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags assigned to a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource to list tags for.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// List the Amazon Redshift Serverless versions.
    @Sendable
    @inlinable
    public func listTracks(_ input: ListTracksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTracksResponse {
        try await self.client.execute(
            operation: "ListTracks", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List the Amazon Redshift Serverless versions.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of response records to return in each call.  If the number of remaining response records exceeds the specified  MaxRecords value, a value is returned in a marker field of the response.  You can retrieve the next set of records by retrying the command with the  returned marker value.
    ///   - nextToken: If your initial ListTracksRequest operation returns a  nextToken, you can include the returned nextToken in following ListTracksRequest operations, which returns results in the next page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTracks(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTracksResponse {
        let input = ListTracksRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listTracks(input, logger: logger)
    }

    /// Lists all usage limits within Amazon Redshift Serverless.
    @Sendable
    @inlinable
    public func listUsageLimits(_ input: ListUsageLimitsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUsageLimitsResponse {
        try await self.client.execute(
            operation: "ListUsageLimits", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all usage limits within Amazon Redshift Serverless.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to get the next page of results. The default is 100.
    ///   - nextToken: If your initial ListUsageLimits operation returns a nextToken, you can include the returned nextToken in following ListUsageLimits operations, which returns results in the next page.
    ///   - resourceArn: The Amazon Resource Name (ARN) associated with the resource whose usage limits you want to list.
    ///   - usageType: The Amazon Redshift Serverless feature whose limits you want to see.
    ///   - logger: Logger use during operation
    @inlinable
    public func listUsageLimits(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceArn: String? = nil,
        usageType: UsageLimitUsageType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUsageLimitsResponse {
        let input = ListUsageLimitsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceArn: resourceArn, 
            usageType: usageType
        )
        return try await self.listUsageLimits(input, logger: logger)
    }

    /// Returns information about a list of specified workgroups.
    @Sendable
    @inlinable
    public func listWorkgroups(_ input: ListWorkgroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListWorkgroupsResponse {
        try await self.client.execute(
            operation: "ListWorkgroups", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a list of specified workgroups.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - nextToken: If your initial ListWorkgroups operation returns a nextToken, you can include the returned nextToken in following ListNamespaces operations, which returns results in the next page.
    ///   - ownerAccount: The owner Amazon Web Services account for the Amazon Redshift Serverless workgroup.
    ///   - logger: Logger use during operation
    @inlinable
    public func listWorkgroups(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        ownerAccount: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListWorkgroupsResponse {
        let input = ListWorkgroupsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            ownerAccount: ownerAccount
        )
        return try await self.listWorkgroups(input, logger: logger)
    }

    /// Creates or updates a resource policy. Currently, you can use policies to share snapshots across Amazon Web Services accounts.
    @Sendable
    @inlinable
    public func putResourcePolicy(_ input: PutResourcePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutResourcePolicyResponse {
        try await self.client.execute(
            operation: "PutResourcePolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates or updates a resource policy. Currently, you can use policies to share snapshots across Amazon Web Services accounts.
    ///
    /// Parameters:
    ///   - policy: The policy to create or update. For example, the following policy grants a user authorization to restore a snapshot.  "{\"Version\": \"2012-10-17\", \"Statement\" :  [{ \"Sid\": \"AllowUserRestoreFromSnapshot\", \"Principal\":{\"AWS\":  [\"739247239426\"]}, \"Action\": [\"redshift-serverless:RestoreFromSnapshot\"] , \"Effect\": \"Allow\" }]}"
    ///   - resourceArn: The Amazon Resource Name (ARN) of the account to create or update a resource policy for.
    ///   - logger: Logger use during operation
    @inlinable
    public func putResourcePolicy(
        policy: String,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutResourcePolicyResponse {
        let input = PutResourcePolicyRequest(
            policy: policy, 
            resourceArn: resourceArn
        )
        return try await self.putResourcePolicy(input, logger: logger)
    }

    /// Restore the data from a recovery point.
    @Sendable
    @inlinable
    public func restoreFromRecoveryPoint(_ input: RestoreFromRecoveryPointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RestoreFromRecoveryPointResponse {
        try await self.client.execute(
            operation: "RestoreFromRecoveryPoint", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Restore the data from a recovery point.
    ///
    /// Parameters:
    ///   - namespaceName: The name of the namespace to restore data into.
    ///   - recoveryPointId: The unique identifier of the recovery point to restore from.
    ///   - workgroupName: The name of the workgroup used to restore data.
    ///   - logger: Logger use during operation
    @inlinable
    public func restoreFromRecoveryPoint(
        namespaceName: String,
        recoveryPointId: String,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RestoreFromRecoveryPointResponse {
        let input = RestoreFromRecoveryPointRequest(
            namespaceName: namespaceName, 
            recoveryPointId: recoveryPointId, 
            workgroupName: workgroupName
        )
        return try await self.restoreFromRecoveryPoint(input, logger: logger)
    }

    /// Restores a namespace from a snapshot.
    @Sendable
    @inlinable
    public func restoreFromSnapshot(_ input: RestoreFromSnapshotRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RestoreFromSnapshotResponse {
        try await self.client.execute(
            operation: "RestoreFromSnapshot", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Restores a namespace from a snapshot.
    ///
    /// Parameters:
    ///   - adminPasswordSecretKmsKeyId: The ID of the Key Management Service (KMS) key used to encrypt and store the namespace's admin credentials secret.
    ///   - manageAdminPassword: If true, Amazon Redshift uses Secrets Manager to manage the restored  snapshot's admin credentials. If MmanageAdminPassword is false or not set,  Amazon Redshift uses the admin credentials that the namespace or cluster  had at the time the snapshot was taken.
    ///   - namespaceName: The name of the namespace to restore the snapshot to.
    ///   - ownerAccount: The Amazon Web Services account that owns the snapshot.
    ///   - snapshotArn: The Amazon Resource Name (ARN) of the snapshot to restore from. Required if restoring from a provisioned cluster to Amazon Redshift Serverless. Must not be specified at the same time as snapshotName. The format of the ARN is arn:aws:redshift:&lt;region&gt;:&lt;account_id&gt;:snapshot:&lt;cluster_identifier&gt;/&lt;snapshot_identifier&gt;.
    ///   - snapshotName: The name of the snapshot to restore from. Must not be specified at the same time as snapshotArn.
    ///   - workgroupName: The name of the workgroup used to restore the snapshot.
    ///   - logger: Logger use during operation
    @inlinable
    public func restoreFromSnapshot(
        adminPasswordSecretKmsKeyId: String? = nil,
        manageAdminPassword: Bool? = nil,
        namespaceName: String,
        ownerAccount: String? = nil,
        snapshotArn: String? = nil,
        snapshotName: String? = nil,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RestoreFromSnapshotResponse {
        let input = RestoreFromSnapshotRequest(
            adminPasswordSecretKmsKeyId: adminPasswordSecretKmsKeyId, 
            manageAdminPassword: manageAdminPassword, 
            namespaceName: namespaceName, 
            ownerAccount: ownerAccount, 
            snapshotArn: snapshotArn, 
            snapshotName: snapshotName, 
            workgroupName: workgroupName
        )
        return try await self.restoreFromSnapshot(input, logger: logger)
    }

    /// Restores a table from a recovery point to your Amazon Redshift Serverless instance. You can't use this operation to restore tables with interleaved sort keys.
    @Sendable
    @inlinable
    public func restoreTableFromRecoveryPoint(_ input: RestoreTableFromRecoveryPointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RestoreTableFromRecoveryPointResponse {
        try await self.client.execute(
            operation: "RestoreTableFromRecoveryPoint", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Restores a table from a recovery point to your Amazon Redshift Serverless instance. You can't use this operation to restore tables with interleaved sort keys.
    ///
    /// Parameters:
    ///   - activateCaseSensitiveIdentifier: Indicates whether name identifiers for database, schema, and table are case sensitive. If true, the names are case sensitive. If false, the names are not case sensitive. The default is false.
    ///   - namespaceName: Namespace of the recovery point to restore from.
    ///   - newTableName: The name of the table to create from the restore operation.
    ///   - recoveryPointId: The ID of the recovery point to restore the table from.
    ///   - sourceDatabaseName: The name of the source database that contains the table being restored.
    ///   - sourceSchemaName: The name of the source schema that contains the table being restored.
    ///   - sourceTableName: The name of the source table being restored.
    ///   - targetDatabaseName: The name of the database to restore the table to.
    ///   - targetSchemaName: The name of the schema to restore the table to.
    ///   - workgroupName: The workgroup to restore the table to.
    ///   - logger: Logger use during operation
    @inlinable
    public func restoreTableFromRecoveryPoint(
        activateCaseSensitiveIdentifier: Bool? = nil,
        namespaceName: String,
        newTableName: String,
        recoveryPointId: String,
        sourceDatabaseName: String,
        sourceSchemaName: String? = nil,
        sourceTableName: String,
        targetDatabaseName: String? = nil,
        targetSchemaName: String? = nil,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RestoreTableFromRecoveryPointResponse {
        let input = RestoreTableFromRecoveryPointRequest(
            activateCaseSensitiveIdentifier: activateCaseSensitiveIdentifier, 
            namespaceName: namespaceName, 
            newTableName: newTableName, 
            recoveryPointId: recoveryPointId, 
            sourceDatabaseName: sourceDatabaseName, 
            sourceSchemaName: sourceSchemaName, 
            sourceTableName: sourceTableName, 
            targetDatabaseName: targetDatabaseName, 
            targetSchemaName: targetSchemaName, 
            workgroupName: workgroupName
        )
        return try await self.restoreTableFromRecoveryPoint(input, logger: logger)
    }

    /// Restores a table from a snapshot to your Amazon Redshift Serverless instance. You can't use this operation to restore tables with interleaved sort keys.
    @Sendable
    @inlinable
    public func restoreTableFromSnapshot(_ input: RestoreTableFromSnapshotRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RestoreTableFromSnapshotResponse {
        try await self.client.execute(
            operation: "RestoreTableFromSnapshot", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Restores a table from a snapshot to your Amazon Redshift Serverless instance. You can't use this operation to restore tables with interleaved sort keys.
    ///
    /// Parameters:
    ///   - activateCaseSensitiveIdentifier: Indicates whether name identifiers for database, schema, and table  are case sensitive. If true, the names are case sensitive. If  false, the names are not case sensitive. The default is false.
    ///   - namespaceName: The namespace of the snapshot to restore from.
    ///   - newTableName: The name of the table to create from the restore operation.
    ///   - snapshotName: The name of the snapshot to restore the table from.
    ///   - sourceDatabaseName: The name of the source database that contains the table being restored.
    ///   - sourceSchemaName: The name of the source schema that contains the table being restored.
    ///   - sourceTableName: The name of the source table being restored.
    ///   - targetDatabaseName: The name of the database to restore the table to.
    ///   - targetSchemaName: The name of the schema to restore the table to.
    ///   - workgroupName: The workgroup to restore the table to.
    ///   - logger: Logger use during operation
    @inlinable
    public func restoreTableFromSnapshot(
        activateCaseSensitiveIdentifier: Bool? = nil,
        namespaceName: String,
        newTableName: String,
        snapshotName: String,
        sourceDatabaseName: String,
        sourceSchemaName: String? = nil,
        sourceTableName: String,
        targetDatabaseName: String? = nil,
        targetSchemaName: String? = nil,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RestoreTableFromSnapshotResponse {
        let input = RestoreTableFromSnapshotRequest(
            activateCaseSensitiveIdentifier: activateCaseSensitiveIdentifier, 
            namespaceName: namespaceName, 
            newTableName: newTableName, 
            snapshotName: snapshotName, 
            sourceDatabaseName: sourceDatabaseName, 
            sourceSchemaName: sourceSchemaName, 
            sourceTableName: sourceTableName, 
            targetDatabaseName: targetDatabaseName, 
            targetSchemaName: targetSchemaName, 
            workgroupName: workgroupName
        )
        return try await self.restoreTableFromSnapshot(input, logger: logger)
    }

    /// Assigns one or more tags to a resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Assigns one or more tags to a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource to tag.
    ///   - tags: The map of the key-value pairs used to tag the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes a tag or set of tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a tag or set of tags from a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource to remove tags from.
    ///   - tagKeys: The tag or set of tags to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates an Amazon Redshift Serverless certificate associated with a custom domain.
    @Sendable
    @inlinable
    public func updateCustomDomainAssociation(_ input: UpdateCustomDomainAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCustomDomainAssociationResponse {
        try await self.client.execute(
            operation: "UpdateCustomDomainAssociation", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an Amazon Redshift Serverless certificate associated with a custom domain.
    ///
    /// Parameters:
    ///   - customDomainCertificateArn: The custom domain name’s certificate Amazon resource name (ARN). This is optional.
    ///   - customDomainName: The custom domain name associated with the workgroup.
    ///   - workgroupName: The name of the workgroup associated with the database.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCustomDomainAssociation(
        customDomainCertificateArn: String,
        customDomainName: String,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCustomDomainAssociationResponse {
        let input = UpdateCustomDomainAssociationRequest(
            customDomainCertificateArn: customDomainCertificateArn, 
            customDomainName: customDomainName, 
            workgroupName: workgroupName
        )
        return try await self.updateCustomDomainAssociation(input, logger: logger)
    }

    /// Updates an Amazon Redshift Serverless managed endpoint.
    @Sendable
    @inlinable
    public func updateEndpointAccess(_ input: UpdateEndpointAccessRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEndpointAccessResponse {
        try await self.client.execute(
            operation: "UpdateEndpointAccess", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an Amazon Redshift Serverless managed endpoint.
    ///
    /// Parameters:
    ///   - endpointName: The name of the VPC endpoint to update.
    ///   - vpcSecurityGroupIds: The list of VPC security groups associated with the endpoint after the endpoint is modified.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEndpointAccess(
        endpointName: String,
        vpcSecurityGroupIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEndpointAccessResponse {
        let input = UpdateEndpointAccessRequest(
            endpointName: endpointName, 
            vpcSecurityGroupIds: vpcSecurityGroupIds
        )
        return try await self.updateEndpointAccess(input, logger: logger)
    }

    /// Updates a namespace with the specified settings. Unless required, you can't update multiple parameters in one request. For example, you must specify both adminUsername and adminUserPassword to update either field, but you can't update both kmsKeyId and logExports in a single request.
    @Sendable
    @inlinable
    public func updateNamespace(_ input: UpdateNamespaceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateNamespaceResponse {
        try await self.client.execute(
            operation: "UpdateNamespace", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a namespace with the specified settings. Unless required, you can't update multiple parameters in one request. For example, you must specify both adminUsername and adminUserPassword to update either field, but you can't update both kmsKeyId and logExports in a single request.
    ///
    /// Parameters:
    ///   - adminPasswordSecretKmsKeyId: The ID of the Key Management Service (KMS) key used to encrypt and store the namespace's admin credentials secret.  You can only use this parameter if manageAdminPassword is true.
    ///   - adminUsername: The username of the administrator for the first database created in the namespace. This parameter must be updated together with adminUserPassword.
    ///   - adminUserPassword: The password of the administrator for the first database created in the namespace. This parameter must be updated together with adminUsername. You can't use adminUserPassword if manageAdminPassword is true.
    ///   - defaultIamRoleArn: The Amazon Resource Name (ARN) of the IAM role to set as a default in the namespace. This parameter must be updated together with iamRoles.
    ///   - iamRoles: A list of IAM roles to associate with the namespace. This parameter must be updated together with defaultIamRoleArn.
    ///   - kmsKeyId: The ID of the Amazon Web Services Key Management Service key used to encrypt your data.
    ///   - logExports: The types of logs the namespace can export. The export types are userlog, connectionlog, and useractivitylog.
    ///   - manageAdminPassword: If true, Amazon Redshift uses Secrets Manager to manage the namespace's admin credentials.  You can't use adminUserPassword if manageAdminPassword is true.  If manageAdminPassword is false or not set, Amazon Redshift uses  adminUserPassword for the admin user account's password.
    ///   - namespaceName: The name of the namespace to update. You can't update the name of a namespace once it is created.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateNamespace(
        adminPasswordSecretKmsKeyId: String? = nil,
        adminUsername: String? = nil,
        adminUserPassword: String? = nil,
        defaultIamRoleArn: String? = nil,
        iamRoles: [String]? = nil,
        kmsKeyId: String? = nil,
        logExports: [LogExport]? = nil,
        manageAdminPassword: Bool? = nil,
        namespaceName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateNamespaceResponse {
        let input = UpdateNamespaceRequest(
            adminPasswordSecretKmsKeyId: adminPasswordSecretKmsKeyId, 
            adminUsername: adminUsername, 
            adminUserPassword: adminUserPassword, 
            defaultIamRoleArn: defaultIamRoleArn, 
            iamRoles: iamRoles, 
            kmsKeyId: kmsKeyId, 
            logExports: logExports, 
            manageAdminPassword: manageAdminPassword, 
            namespaceName: namespaceName
        )
        return try await self.updateNamespace(input, logger: logger)
    }

    /// Updates a scheduled action.
    @Sendable
    @inlinable
    public func updateScheduledAction(_ input: UpdateScheduledActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateScheduledActionResponse {
        try await self.client.execute(
            operation: "UpdateScheduledAction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a scheduled action.
    ///
    /// Parameters:
    ///   - enabled: Specifies whether to enable the scheduled action.
    ///   - endTime: The end time in UTC of the scheduled action to update.
    ///   - roleArn: The ARN of the IAM role to assume to run the scheduled action. This IAM role must have permission to run the Amazon Redshift Serverless API operation in the scheduled action.  This IAM role must allow the Amazon Redshift scheduler to schedule creating snapshots (Principal scheduler.redshift.amazonaws.com) to assume permissions on your behalf.  For more information about the IAM role to use with the Amazon Redshift scheduler, see Using Identity-Based Policies for  Amazon Redshift in the Amazon Redshift Management Guide
    ///   - schedule: The schedule for a one-time (at timestamp format) or recurring (cron format) scheduled action. Schedule invocations must be separated by at least one hour. Times are in UTC.   Format of at timestamp is yyyy-mm-ddThh:mm:ss. For example, 2016-03-04T17:27:00.   Format of cron expression is (Minutes Hours Day-of-month Month Day-of-week Year). For example, "(0 10 ? * MON *)". For more information, see  Cron Expressions in the Amazon CloudWatch Events User Guide.
    ///   - scheduledActionDescription: The descripion of the scheduled action to update to.
    ///   - scheduledActionName: The name of the scheduled action to update to.
    ///   - startTime: The start time in UTC of the scheduled action to update to.
    ///   - targetAction: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateScheduledAction(
        enabled: Bool? = nil,
        endTime: Date? = nil,
        roleArn: String? = nil,
        schedule: Schedule? = nil,
        scheduledActionDescription: String? = nil,
        scheduledActionName: String,
        startTime: Date? = nil,
        targetAction: TargetAction? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateScheduledActionResponse {
        let input = UpdateScheduledActionRequest(
            enabled: enabled, 
            endTime: endTime, 
            roleArn: roleArn, 
            schedule: schedule, 
            scheduledActionDescription: scheduledActionDescription, 
            scheduledActionName: scheduledActionName, 
            startTime: startTime, 
            targetAction: targetAction
        )
        return try await self.updateScheduledAction(input, logger: logger)
    }

    /// Updates a snapshot.
    @Sendable
    @inlinable
    public func updateSnapshot(_ input: UpdateSnapshotRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSnapshotResponse {
        try await self.client.execute(
            operation: "UpdateSnapshot", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a snapshot.
    ///
    /// Parameters:
    ///   - retentionPeriod: The new retention period of the snapshot.
    ///   - snapshotName: The name of the snapshot.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSnapshot(
        retentionPeriod: Int? = nil,
        snapshotName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSnapshotResponse {
        let input = UpdateSnapshotRequest(
            retentionPeriod: retentionPeriod, 
            snapshotName: snapshotName
        )
        return try await self.updateSnapshot(input, logger: logger)
    }

    /// Updates a snapshot copy configuration.
    @Sendable
    @inlinable
    public func updateSnapshotCopyConfiguration(_ input: UpdateSnapshotCopyConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSnapshotCopyConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateSnapshotCopyConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a snapshot copy configuration.
    ///
    /// Parameters:
    ///   - snapshotCopyConfigurationId: The ID of the snapshot copy configuration to update.
    ///   - snapshotRetentionPeriod: The new retention period of how long to keep a snapshot in the destination Amazon Web Services Region.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSnapshotCopyConfiguration(
        snapshotCopyConfigurationId: String,
        snapshotRetentionPeriod: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSnapshotCopyConfigurationResponse {
        let input = UpdateSnapshotCopyConfigurationRequest(
            snapshotCopyConfigurationId: snapshotCopyConfigurationId, 
            snapshotRetentionPeriod: snapshotRetentionPeriod
        )
        return try await self.updateSnapshotCopyConfiguration(input, logger: logger)
    }

    /// Update a usage limit in Amazon Redshift Serverless. You can't update the usage type or period of a usage limit.
    @Sendable
    @inlinable
    public func updateUsageLimit(_ input: UpdateUsageLimitRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateUsageLimitResponse {
        try await self.client.execute(
            operation: "UpdateUsageLimit", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update a usage limit in Amazon Redshift Serverless. You can't update the usage type or period of a usage limit.
    ///
    /// Parameters:
    ///   - amount: The new limit amount. If time-based, this amount is in Redshift Processing Units (RPU) consumed per hour.  If data-based, this amount is in terabytes (TB) of data transferred between Regions in cross-account sharing.  The value must be a positive number.
    ///   - breachAction: The new action that Amazon Redshift Serverless takes when the limit is reached.
    ///   - usageLimitId: The identifier of the usage limit to update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUsageLimit(
        amount: Int64? = nil,
        breachAction: UsageLimitBreachAction? = nil,
        usageLimitId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateUsageLimitResponse {
        let input = UpdateUsageLimitRequest(
            amount: amount, 
            breachAction: breachAction, 
            usageLimitId: usageLimitId
        )
        return try await self.updateUsageLimit(input, logger: logger)
    }

    /// Updates a workgroup with the specified configuration settings. You can't update multiple parameters in one request. For example, you can update baseCapacity or port in a single request, but you can't update both in the same request. VPC Block Public Access (BPA) enables you to block resources in VPCs and subnets that you own in a Region from reaching or being reached from the internet through internet gateways and egress-only internet gateways. If a workgroup is in an account with VPC BPA turned on, the following capabilities are blocked:    Creating a public access workgroup   Modifying a private workgroup to public   Adding a subnet with VPC BPA turned on to the workgroup when the workgroup is public   For more information about VPC BPA, see Block public access to VPCs and subnets in the Amazon VPC User Guide.
    @Sendable
    @inlinable
    public func updateWorkgroup(_ input: UpdateWorkgroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateWorkgroupResponse {
        try await self.client.execute(
            operation: "UpdateWorkgroup", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a workgroup with the specified configuration settings. You can't update multiple parameters in one request. For example, you can update baseCapacity or port in a single request, but you can't update both in the same request. VPC Block Public Access (BPA) enables you to block resources in VPCs and subnets that you own in a Region from reaching or being reached from the internet through internet gateways and egress-only internet gateways. If a workgroup is in an account with VPC BPA turned on, the following capabilities are blocked:    Creating a public access workgroup   Modifying a private workgroup to public   Adding a subnet with VPC BPA turned on to the workgroup when the workgroup is public   For more information about VPC BPA, see Block public access to VPCs and subnets in the Amazon VPC User Guide.
    ///
    /// Parameters:
    ///   - baseCapacity: The new base data warehouse capacity in Redshift Processing Units (RPUs).
    ///   - configParameters: An array of parameters to set for advanced control over a database. The options are auto_mv, datestyle, enable_case_sensitive_identifier, enable_user_activity_logging, query_group, search_path, require_ssl, use_fips_ssl, and query monitoring metrics that let you  define performance boundaries. For more information about query monitoring rules and available metrics, see   Query monitoring metrics for Amazon Redshift Serverless.
    ///   - enhancedVpcRouting: The value that specifies whether to turn on enhanced virtual  private cloud (VPC) routing, which forces Amazon Redshift Serverless to route traffic through your VPC.
    ///   - ipAddressType: The IP address type that the workgroup supports. Possible values are ipv4 and dualstack.
    ///   - maxCapacity: The maximum data-warehouse capacity Amazon Redshift Serverless uses to serve queries. The max capacity is specified in RPUs.
    ///   - port: The custom port to use when connecting to a workgroup. Valid port ranges are 5431-5455 and 8191-8215. The default is 5439.
    ///   - pricePerformanceTarget: An object that represents the price performance target settings for the workgroup.
    ///   - publiclyAccessible: A value that specifies whether the workgroup can be accessible from a public network.
    ///   - securityGroupIds: An array of security group IDs to associate with the workgroup.
    ///   - subnetIds: An array of VPC subnet IDs to associate with the workgroup.
    ///   - trackName: An optional parameter for the name of the track for the workgroup. If you don't provide  a track name, the workgroup is assigned to the current track.
    ///   - workgroupName: The name of the workgroup to update. You can't update the name of a workgroup once it is created.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateWorkgroup(
        baseCapacity: Int? = nil,
        configParameters: [ConfigParameter]? = nil,
        enhancedVpcRouting: Bool? = nil,
        ipAddressType: String? = nil,
        maxCapacity: Int? = nil,
        port: Int? = nil,
        pricePerformanceTarget: PerformanceTarget? = nil,
        publiclyAccessible: Bool? = nil,
        securityGroupIds: [String]? = nil,
        subnetIds: [String]? = nil,
        trackName: String? = nil,
        workgroupName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateWorkgroupResponse {
        let input = UpdateWorkgroupRequest(
            baseCapacity: baseCapacity, 
            configParameters: configParameters, 
            enhancedVpcRouting: enhancedVpcRouting, 
            ipAddressType: ipAddressType, 
            maxCapacity: maxCapacity, 
            port: port, 
            pricePerformanceTarget: pricePerformanceTarget, 
            publiclyAccessible: publiclyAccessible, 
            securityGroupIds: securityGroupIds, 
            subnetIds: subnetIds, 
            trackName: trackName, 
            workgroupName: workgroupName
        )
        return try await self.updateWorkgroup(input, logger: logger)
    }
}

extension RedshiftServerless {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: RedshiftServerless, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension RedshiftServerless {
    /// Return PaginatorSequence for operation ``listCustomDomainAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCustomDomainAssociationsPaginator(
        _ input: ListCustomDomainAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCustomDomainAssociationsRequest, ListCustomDomainAssociationsResponse> {
        return .init(
            input: input,
            command: self.listCustomDomainAssociations,
            inputKey: \ListCustomDomainAssociationsRequest.nextToken,
            outputKey: \ListCustomDomainAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCustomDomainAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - customDomainCertificateArn: The custom domain name’s certificate Amazon resource name (ARN).
    ///   - customDomainName: The custom domain name associated with the workgroup.
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCustomDomainAssociationsPaginator(
        customDomainCertificateArn: String? = nil,
        customDomainName: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCustomDomainAssociationsRequest, ListCustomDomainAssociationsResponse> {
        let input = ListCustomDomainAssociationsRequest(
            customDomainCertificateArn: customDomainCertificateArn, 
            customDomainName: customDomainName, 
            maxResults: maxResults
        )
        return self.listCustomDomainAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listEndpointAccess(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listEndpointAccessPaginator(
        _ input: ListEndpointAccessRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListEndpointAccessRequest, ListEndpointAccessResponse> {
        return .init(
            input: input,
            command: self.listEndpointAccess,
            inputKey: \ListEndpointAccessRequest.nextToken,
            outputKey: \ListEndpointAccessResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listEndpointAccess(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - ownerAccount: The owner Amazon Web Services account for the Amazon Redshift Serverless workgroup.
    ///   - vpcId: The unique identifier of the virtual private cloud with access to Amazon Redshift Serverless.
    ///   - workgroupName: The name of the workgroup associated with the VPC endpoint to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listEndpointAccessPaginator(
        maxResults: Int? = nil,
        ownerAccount: String? = nil,
        vpcId: String? = nil,
        workgroupName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListEndpointAccessRequest, ListEndpointAccessResponse> {
        let input = ListEndpointAccessRequest(
            maxResults: maxResults, 
            ownerAccount: ownerAccount, 
            vpcId: vpcId, 
            workgroupName: workgroupName
        )
        return self.listEndpointAccessPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listManagedWorkgroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedWorkgroupsPaginator(
        _ input: ListManagedWorkgroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListManagedWorkgroupsRequest, ListManagedWorkgroupsResponse> {
        return .init(
            input: input,
            command: self.listManagedWorkgroups,
            inputKey: \ListManagedWorkgroupsRequest.nextToken,
            outputKey: \ListManagedWorkgroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listManagedWorkgroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number  of results to return. You can use nextToken to display the next page of results.
    ///   - sourceArn: The Amazon Resource Name (ARN) for the managed  workgroup in the AWS Glue Data Catalog.
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedWorkgroupsPaginator(
        maxResults: Int? = nil,
        sourceArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListManagedWorkgroupsRequest, ListManagedWorkgroupsResponse> {
        let input = ListManagedWorkgroupsRequest(
            maxResults: maxResults, 
            sourceArn: sourceArn
        )
        return self.listManagedWorkgroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNamespaces(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNamespacesPaginator(
        _ input: ListNamespacesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNamespacesRequest, ListNamespacesResponse> {
        return .init(
            input: input,
            command: self.listNamespaces,
            inputKey: \ListNamespacesRequest.nextToken,
            outputKey: \ListNamespacesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNamespaces(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNamespacesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNamespacesRequest, ListNamespacesResponse> {
        let input = ListNamespacesRequest(
            maxResults: maxResults
        )
        return self.listNamespacesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRecoveryPoints(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRecoveryPointsPaginator(
        _ input: ListRecoveryPointsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRecoveryPointsRequest, ListRecoveryPointsResponse> {
        return .init(
            input: input,
            command: self.listRecoveryPoints,
            inputKey: \ListRecoveryPointsRequest.nextToken,
            outputKey: \ListRecoveryPointsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRecoveryPoints(_:logger:)``.
    ///
    /// - Parameters:
    ///   - endTime: The time when creation of the recovery point finished.
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - namespaceArn: The Amazon Resource Name (ARN) of the namespace from which to list recovery points.
    ///   - namespaceName: The name of the namespace to list recovery points for.
    ///   - startTime: The time when the recovery point's creation was initiated.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRecoveryPointsPaginator(
        endTime: Date? = nil,
        maxResults: Int? = nil,
        namespaceArn: String? = nil,
        namespaceName: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRecoveryPointsRequest, ListRecoveryPointsResponse> {
        let input = ListRecoveryPointsRequest(
            endTime: endTime, 
            maxResults: maxResults, 
            namespaceArn: namespaceArn, 
            namespaceName: namespaceName, 
            startTime: startTime
        )
        return self.listRecoveryPointsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReservationOfferings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReservationOfferingsPaginator(
        _ input: ListReservationOfferingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReservationOfferingsRequest, ListReservationOfferingsResponse> {
        return .init(
            input: input,
            command: self.listReservationOfferings,
            inputKey: \ListReservationOfferingsRequest.nextToken,
            outputKey: \ListReservationOfferingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReservationOfferings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of items to return for this call. The call also returns a token that you can specify in a subsequent call to get the next set of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReservationOfferingsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReservationOfferingsRequest, ListReservationOfferingsResponse> {
        let input = ListReservationOfferingsRequest(
            maxResults: maxResults
        )
        return self.listReservationOfferingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listReservations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listReservationsPaginator(
        _ input: ListReservationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListReservationsRequest, ListReservationsResponse> {
        return .init(
            input: input,
            command: self.listReservations,
            inputKey: \ListReservationsRequest.nextToken,
            outputKey: \ListReservationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listReservations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of items to return for this call. The call also returns a token that you can specify in a subsequent call to get the next set of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listReservationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListReservationsRequest, ListReservationsResponse> {
        let input = ListReservationsRequest(
            maxResults: maxResults
        )
        return self.listReservationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listScheduledActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listScheduledActionsPaginator(
        _ input: ListScheduledActionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListScheduledActionsRequest, ListScheduledActionsResponse> {
        return .init(
            input: input,
            command: self.listScheduledActions,
            inputKey: \ListScheduledActionsRequest.nextToken,
            outputKey: \ListScheduledActionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listScheduledActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. Use nextToken to display the next page of results.
    ///   - namespaceName: The name of namespace associated with the scheduled action to retrieve.
    ///   - logger: Logger used for logging
    @inlinable
    public func listScheduledActionsPaginator(
        maxResults: Int? = nil,
        namespaceName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListScheduledActionsRequest, ListScheduledActionsResponse> {
        let input = ListScheduledActionsRequest(
            maxResults: maxResults, 
            namespaceName: namespaceName
        )
        return self.listScheduledActionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSnapshotCopyConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSnapshotCopyConfigurationsPaginator(
        _ input: ListSnapshotCopyConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSnapshotCopyConfigurationsRequest, ListSnapshotCopyConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listSnapshotCopyConfigurations,
            inputKey: \ListSnapshotCopyConfigurationsRequest.nextToken,
            outputKey: \ListSnapshotCopyConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSnapshotCopyConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - namespaceName: The namespace from which to list all snapshot copy configurations.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSnapshotCopyConfigurationsPaginator(
        maxResults: Int? = nil,
        namespaceName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSnapshotCopyConfigurationsRequest, ListSnapshotCopyConfigurationsResponse> {
        let input = ListSnapshotCopyConfigurationsRequest(
            maxResults: maxResults, 
            namespaceName: namespaceName
        )
        return self.listSnapshotCopyConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSnapshots(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSnapshotsPaginator(
        _ input: ListSnapshotsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSnapshotsRequest, ListSnapshotsResponse> {
        return .init(
            input: input,
            command: self.listSnapshots,
            inputKey: \ListSnapshotsRequest.nextToken,
            outputKey: \ListSnapshotsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSnapshots(_:logger:)``.
    ///
    /// - Parameters:
    ///   - endTime: The timestamp showing when the snapshot creation finished.
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - namespaceArn: The Amazon Resource Name (ARN) of the namespace from which to list all snapshots.
    ///   - namespaceName: The namespace from which to list all snapshots.
    ///   - ownerAccount: The owner Amazon Web Services account of the snapshot.
    ///   - startTime: The time when the creation of the snapshot was initiated.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSnapshotsPaginator(
        endTime: Date? = nil,
        maxResults: Int? = nil,
        namespaceArn: String? = nil,
        namespaceName: String? = nil,
        ownerAccount: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSnapshotsRequest, ListSnapshotsResponse> {
        let input = ListSnapshotsRequest(
            endTime: endTime, 
            maxResults: maxResults, 
            namespaceArn: namespaceArn, 
            namespaceName: namespaceName, 
            ownerAccount: ownerAccount, 
            startTime: startTime
        )
        return self.listSnapshotsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTableRestoreStatus(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTableRestoreStatusPaginator(
        _ input: ListTableRestoreStatusRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTableRestoreStatusRequest, ListTableRestoreStatusResponse> {
        return .init(
            input: input,
            command: self.listTableRestoreStatus,
            inputKey: \ListTableRestoreStatusRequest.nextToken,
            outputKey: \ListTableRestoreStatusResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTableRestoreStatus(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to  return. You can use nextToken to display the next page of results.
    ///   - namespaceName: The namespace from which to list all of the statuses of RestoreTableFromSnapshot operations .
    ///   - workgroupName: The workgroup from which to list all of the statuses of RestoreTableFromSnapshot operations.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTableRestoreStatusPaginator(
        maxResults: Int? = nil,
        namespaceName: String? = nil,
        workgroupName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTableRestoreStatusRequest, ListTableRestoreStatusResponse> {
        let input = ListTableRestoreStatusRequest(
            maxResults: maxResults, 
            namespaceName: namespaceName, 
            workgroupName: workgroupName
        )
        return self.listTableRestoreStatusPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTracks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTracksPaginator(
        _ input: ListTracksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTracksRequest, ListTracksResponse> {
        return .init(
            input: input,
            command: self.listTracks,
            inputKey: \ListTracksRequest.nextToken,
            outputKey: \ListTracksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTracks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of response records to return in each call.  If the number of remaining response records exceeds the specified  MaxRecords value, a value is returned in a marker field of the response.  You can retrieve the next set of records by retrying the command with the  returned marker value.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTracksPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTracksRequest, ListTracksResponse> {
        let input = ListTracksRequest(
            maxResults: maxResults
        )
        return self.listTracksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUsageLimits(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUsageLimitsPaginator(
        _ input: ListUsageLimitsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUsageLimitsRequest, ListUsageLimitsResponse> {
        return .init(
            input: input,
            command: self.listUsageLimits,
            inputKey: \ListUsageLimitsRequest.nextToken,
            outputKey: \ListUsageLimitsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUsageLimits(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to get the next page of results. The default is 100.
    ///   - resourceArn: The Amazon Resource Name (ARN) associated with the resource whose usage limits you want to list.
    ///   - usageType: The Amazon Redshift Serverless feature whose limits you want to see.
    ///   - logger: Logger used for logging
    @inlinable
    public func listUsageLimitsPaginator(
        maxResults: Int? = nil,
        resourceArn: String? = nil,
        usageType: UsageLimitUsageType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUsageLimitsRequest, ListUsageLimitsResponse> {
        let input = ListUsageLimitsRequest(
            maxResults: maxResults, 
            resourceArn: resourceArn, 
            usageType: usageType
        )
        return self.listUsageLimitsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listWorkgroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkgroupsPaginator(
        _ input: ListWorkgroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListWorkgroupsRequest, ListWorkgroupsResponse> {
        return .init(
            input: input,
            command: self.listWorkgroups,
            inputKey: \ListWorkgroupsRequest.nextToken,
            outputKey: \ListWorkgroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listWorkgroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to display the next page of results.
    ///   - ownerAccount: The owner Amazon Web Services account for the Amazon Redshift Serverless workgroup.
    ///   - logger: Logger used for logging
    @inlinable
    public func listWorkgroupsPaginator(
        maxResults: Int? = nil,
        ownerAccount: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListWorkgroupsRequest, ListWorkgroupsResponse> {
        let input = ListWorkgroupsRequest(
            maxResults: maxResults, 
            ownerAccount: ownerAccount
        )
        return self.listWorkgroupsPaginator(input, logger: logger)
    }
}

extension RedshiftServerless.ListCustomDomainAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListCustomDomainAssociationsRequest {
        return .init(
            customDomainCertificateArn: self.customDomainCertificateArn,
            customDomainName: self.customDomainName,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension RedshiftServerless.ListEndpointAccessRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListEndpointAccessRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            ownerAccount: self.ownerAccount,
            vpcId: self.vpcId,
            workgroupName: self.workgroupName
        )
    }
}

extension RedshiftServerless.ListManagedWorkgroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListManagedWorkgroupsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            sourceArn: self.sourceArn
        )
    }
}

extension RedshiftServerless.ListNamespacesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListNamespacesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension RedshiftServerless.ListRecoveryPointsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListRecoveryPointsRequest {
        return .init(
            endTime: self.endTime,
            maxResults: self.maxResults,
            namespaceArn: self.namespaceArn,
            namespaceName: self.namespaceName,
            nextToken: token,
            startTime: self.startTime
        )
    }
}

extension RedshiftServerless.ListReservationOfferingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListReservationOfferingsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension RedshiftServerless.ListReservationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListReservationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension RedshiftServerless.ListScheduledActionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListScheduledActionsRequest {
        return .init(
            maxResults: self.maxResults,
            namespaceName: self.namespaceName,
            nextToken: token
        )
    }
}

extension RedshiftServerless.ListSnapshotCopyConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListSnapshotCopyConfigurationsRequest {
        return .init(
            maxResults: self.maxResults,
            namespaceName: self.namespaceName,
            nextToken: token
        )
    }
}

extension RedshiftServerless.ListSnapshotsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListSnapshotsRequest {
        return .init(
            endTime: self.endTime,
            maxResults: self.maxResults,
            namespaceArn: self.namespaceArn,
            namespaceName: self.namespaceName,
            nextToken: token,
            ownerAccount: self.ownerAccount,
            startTime: self.startTime
        )
    }
}

extension RedshiftServerless.ListTableRestoreStatusRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListTableRestoreStatusRequest {
        return .init(
            maxResults: self.maxResults,
            namespaceName: self.namespaceName,
            nextToken: token,
            workgroupName: self.workgroupName
        )
    }
}

extension RedshiftServerless.ListTracksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListTracksRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension RedshiftServerless.ListUsageLimitsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListUsageLimitsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resourceArn: self.resourceArn,
            usageType: self.usageType
        )
    }
}

extension RedshiftServerless.ListWorkgroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> RedshiftServerless.ListWorkgroupsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            ownerAccount: self.ownerAccount
        )
    }
}
